home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / x / volume6 / vine / patch1 < prev    next >
Encoding:
Internet Message Format  |  1990-03-15  |  15.9 KB
  1. Path: uunet!wyse!mips!apple!sun-barr!newstop!sun!sun.com!argv
  2. From: argv@sun.com
  3. Newsgroups: comp.sources.x
  4. Subject: v06i032: vine, Patch1
  5. Message-ID: <132964@sun.Eng.Sun.COM>
  6. Date: 15 Mar 90 07:44:17 GMT
  7. Sender: news@sun.Eng.Sun.COM
  8. Lines: 592
  9. Approved: argv@sun.com
  10.  
  11. Submitted-by: argv@sun.com
  12. Posting-number: Volume 6, Issue 32
  13. Archive-name: vine/patch1
  14. Patch-To: vine: Volume 6, Issue 25
  15.  
  16. The following patch to vine fixes the problem
  17. with forking.  so, some of the more interesting
  18. parameters now workd:
  19.     vine -C -c
  20.     vince -CfDc
  21. Due to a bug with xnews, you're going to have a problem
  22. allocating colors correctly.  It's been reported already.
  23.  
  24. *** Imakefile.orig    Sat Mar 10 12:41:04 1990
  25. --- Imakefile    Wed Mar 14 11:19:36 1990
  26. ***************
  27. *** 2,8 ****
  28.   #include BandAidCompiler
  29.   #endif
  30.   
  31. ! DEFINES -DX11
  32.   INCLUDES = -I$(TOP) -I$(TOP)/X11
  33.   SYS_LIBRARIES = -lm
  34.   LOCAL_LIBRARIES = $(XLIB)
  35. --- 2,8 ----
  36.   #include BandAidCompiler
  37.   #endif
  38.   
  39. ! DEFINES = -DX11
  40.   INCLUDES = -I$(TOP) -I$(TOP)/X11
  41.   SYS_LIBRARIES = -lm
  42.   LOCAL_LIBRARIES = $(XLIB)
  43. *** version.h.orig    Wed Mar 14 23:02:20 1990
  44. --- version.h    Wed Mar 14 23:02:33 1990
  45. ***************
  46. *** 1,2 ****
  47. ! #define PATCHLEVEL 0
  48. ! #define PATCHDATE  3/9/90
  49. --- 1,2 ----
  50. ! #define PATCHLEVEL 1
  51. ! #define PATCHDATE  3/14/90
  52. *** vine.c.orig    Fri Mar  9 18:44:25 1990
  53. --- vine.c    Wed Mar 14 22:23:11 1990
  54. ***************
  55. *** 5,10 ****
  56. --- 5,13 ----
  57.    *
  58.    *  compile: cc -O -s vine.c -lsunwindow -lpixrect -lm -o vine
  59.    *
  60. +  *  Updating to work on X11 March 1990.
  61. +  *  compile: cc -O -s vine.c -DX11 -lX11 -lm -o vine
  62. +  *
  63.    * The way vines works is a "stem" grows and leaves grow from that stem.
  64.    * The stem and the leaf are arrays of "points" (struct pr_pos).  You can
  65.    * add your own images (like flowers or something) with the -S and -L
  66. ***************
  67. *** 49,55 ****
  68.       "-R N: have N different leaf rotations (max 360)",
  69.   #ifdef X11
  70.       "-d display: use display:server[.screen]",
  71. -     "-F: allow forking; off by default because X server gets confused",
  72.   #else /* X11 */
  73.       "-d device: use alternate frame buffer; default is /dev/fb",
  74.       "-w:  vines grow around each window on the screen (not icons; no color)",
  75. --- 52,57 ----
  76. ***************
  77. *** 73,85 ****
  78.   #include <X11/Xatom.h>
  79.   #include <X11/Xlib.h>
  80.   #include <X11/Xutil.h>
  81. ! struct pr_pos {
  82. !     short x, y;
  83. ! };
  84.   struct rect {
  85.       int    r_left, r_top, r_width, r_height;
  86.   };
  87.   #else /* X11 */
  88.   #include <suntool/tool_hs.h>
  89.   #include <pixrect/pixrect_hs.h>
  90.   #include <suntool/wmgr.h>
  91. --- 75,86 ----
  92.   #include <X11/Xatom.h>
  93.   #include <X11/Xlib.h>
  94.   #include <X11/Xutil.h>
  95. ! typedef XPoint point_t;
  96.   struct rect {
  97.       int    r_left, r_top, r_width, r_height;
  98.   };
  99.   #else /* X11 */
  100. + typedef struct pr_pos point_t;
  101.   #include <suntool/tool_hs.h>
  102.   #include <pixrect/pixrect_hs.h>
  103.   #include <suntool/wmgr.h>
  104. ***************
  105. *** 88,93 ****
  106. --- 89,95 ----
  107.   #define WidthOfScreen(s) s->pr_size.x
  108.   #define HeightOfScreen(s) s->pr_size.y
  109.   #define WUF_WMGR1 0x10
  110. + #define XFlush(dpy) /* not used in Suntools */
  111.   #endif /* X11 */
  112.   
  113.   #include <sys/wait.h>
  114. ***************
  115. *** 118,124 ****
  116.   /*
  117.    * each {x,y} is a relative point to 0,0. End is {0,0} pair
  118.    */
  119. ! struct pr_pos leaf[] = {
  120.       {-4,4}, {-9,6}, {-13,9}, {-15,11}, {-16,14}, {-17,16}, {-17,20},
  121.       {-16,24}, {-13,28}, {-11,30}, {-9,32}, {-4,36}, {-1,38}, {4,39}, {6,37},
  122.       {4,37}, {3,34}, {3,31}, {4,29}, {6,25}, {9,20}, {10,16}, {10,12},
  123. --- 120,126 ----
  124.   /*
  125.    * each {x,y} is a relative point to 0,0. End is {0,0} pair
  126.    */
  127. ! point_t leaf[] = {
  128.       {-4,4}, {-9,6}, {-13,9}, {-15,11}, {-16,14}, {-17,16}, {-17,20},
  129.       {-16,24}, {-13,28}, {-11,30}, {-9,32}, {-4,36}, {-1,38}, {4,39}, {6,37},
  130.       {4,37}, {3,34}, {3,31}, {4,29}, {6,25}, {9,20}, {10,16}, {10,12},
  131. ***************
  132. *** 125,139 ****
  133.       {8,8}, {7,7}, {4,6}, {2,4}, {1,0}, {0,2}, {-1,4}, {-3,8},
  134.       {-5,12}, {-6,16}, {-6,20}, {-5,24}, {-3,27}, {0,0}
  135.   };
  136. ! int leafsize = sizeof (leaf) / sizeof (struct pr_pos);
  137.   
  138. ! struct pr_pos stem[50] = {
  139.       {0,7}, {1,8}, {2,7}, {1,12}, {0,11}, {-1,12}, {-3,15}, {-3,19}, {-2,22},
  140.       {-1,24}, {1,26}, {3,28}, {4,30}, {5,32}, {5,36}, {7,40}, {8,42}, {9,43},
  141.       {8,49}, {5,51}, {2,54}, {0,60}, {0,0}
  142.   };
  143. ! int stemsize = sizeof (stem) / sizeof (struct pr_pos);
  144. ! struct pr_pos leaves[360][sizeof(leaf) / sizeof(struct pr_pos)];
  145.   struct rect win_rects[32];
  146.   
  147.   int reverse;          /*  -r:  reverse video */
  148. --- 127,141 ----
  149.       {8,8}, {7,7}, {4,6}, {2,4}, {1,0}, {0,2}, {-1,4}, {-3,8},
  150.       {-5,12}, {-6,16}, {-6,20}, {-5,24}, {-3,27}, {0,0}
  151.   };
  152. ! int leafsize = sizeof (leaf) / sizeof (point_t);
  153.   
  154. ! point_t stem[50] = {
  155.       {0,7}, {1,8}, {2,7}, {1,12}, {0,11}, {-1,12}, {-3,15}, {-3,19}, {-2,22},
  156.       {-1,24}, {1,26}, {3,28}, {4,30}, {5,32}, {5,36}, {7,40}, {8,42}, {9,43},
  157.       {8,49}, {5,51}, {2,54}, {0,60}, {0,0}
  158.   };
  159. ! int stemsize = sizeof (stem) / sizeof (point_t);
  160. ! point_t leaves[360][sizeof(leaf) / sizeof(point_t)];
  161.   struct rect win_rects[32];
  162.   
  163.   int reverse;          /*  -r:  reverse video */
  164. ***************
  165. *** 150,163 ****
  166.   int do_edges;          /*  -e:  just traverse the edges of the screen */
  167.   int do_windows;       /*  -w:  grow around each open window in suntools */
  168.   int season;          /*  -f:  fall season */
  169. - int do_fork;          /*  -F:  allow forking -- off for X */
  170.   int fade;          /*  -D:  fade the color down the colormap */
  171.   
  172. ! unsigned long colors[256];
  173.   int max_color;        /* maximum number of colors available */
  174.   int win_no, my_win;   /* number of windows running / which win we are */
  175.   int total_forks;      /* the total number of forks we've done so far */
  176.   
  177.   #ifdef X11
  178.   unsigned long intensity;        /* shade of color to paint */
  179.   Display *dpy; /* display */
  180. --- 152,166 ----
  181.   int do_edges;          /*  -e:  just traverse the edges of the screen */
  182.   int do_windows;       /*  -w:  grow around each open window in suntools */
  183.   int season;          /*  -f:  fall season */
  184.   int fade;          /*  -D:  fade the color down the colormap */
  185.   
  186. ! unsigned long colors[255];
  187.   int max_color;        /* maximum number of colors available */
  188.   int win_no, my_win;   /* number of windows running / which win we are */
  189.   int total_forks;      /* the total number of forks we've done so far */
  190.   
  191. + char *prog_name;
  192. + 
  193.   #ifdef X11
  194.   unsigned long intensity;        /* shade of color to paint */
  195.   Display *dpy; /* display */
  196. ***************
  197. *** 185,190 ****
  198. --- 188,195 ----
  199.       int c;
  200.       int dead_kids();
  201.   
  202. +     prog_name = argv[0];
  203. + 
  204.       if (argc > 1)
  205.       parse_args(argc, argv);
  206.       else
  207. ***************
  208. *** 227,265 ****
  209.       }
  210.       }
  211.   
  212. - #ifdef X11
  213. - {
  214. -     void x_error();
  215. -     char *getenv(), *p = getenv("DISPLAY");
  216. -     if (!(dpy = XOpenDisplay(device? device : p? p : ""))) {
  217. -     fprintf(stderr, "%s: unable to open display '%s'\n",
  218. -         argv[0], XDisplayName(p));
  219. -     exit(1);
  220. -     }
  221. -     /* XSynchronize(dpy, 1); */
  222. -     XSetErrorHandler(x_error);
  223. -     screen = ScreenOfDisplay(dpy, DefaultScreen(dpy));
  224. -     win = RootWindowOfScreen(screen);
  225. -     gc = XCreateGC(dpy, win, 0L, NULL);
  226. - }
  227. - #else /* X11 */
  228. - {
  229. -     char groups[PIXPG_OVERLAY+1];
  230. -     if (!(screen = pr_open(device)))
  231. -     exit(1); /* pr_open prints its own error messages (bad idea) */
  232. - 
  233. -     pr_available_plane_groups(screen, sizeof(groups), groups);
  234. - 
  235. -     if (groups[PIXPG_OVERLAY] && groups[PIXPG_OVERLAY_ENABLE] && !is_color) {
  236. -     pr_set_plane_group(screen, PIXPG_OVERLAY_ENABLE);
  237. -     pr_rop(screen, 0,0, WidthOfScreen(screen), HeightOfScreen(screen),
  238. -         PIX_SET, (Pixrect *) 0,0,0);
  239. -     pr_set_plane_group(screen, PIXPG_OVERLAY);
  240. -     }
  241. -     do_fork++;
  242. - }
  243. - #endif /* X11 */
  244. - 
  245.       if (do_halt || from_center)
  246.       /* don't count this fork ... */
  247.       if (fork())
  248. --- 232,237 ----
  249. ***************
  250. *** 274,282 ****
  251.           putchar('.');
  252.       }
  253.       puts(" done.");
  254. !     if (is_color)
  255. !     initialize_color();
  256. !     else if (do_windows) {
  257.       if (!get_windows())
  258.           puts("No windows!");
  259.   
  260. --- 246,254 ----
  261.           putchar('.');
  262.       }
  263.       puts(" done.");
  264. !     init_display();
  265. ! #ifndef X11
  266. !     if (!is_color && do_windows) {
  267.       if (!get_windows())
  268.           puts("No windows!");
  269.   
  270. ***************
  271. *** 291,306 ****
  272.                   win_rects[my_win].r_top, FLOP);
  273.       exit(0);
  274.       }
  275.       y = 1;
  276.       if (do_edges) {
  277. !     if (do_fork) {
  278. !         if (!fork()) {
  279. !         edge_vines(WidthOfScreen(screen) / 2, 10, FLIP);
  280. !         exit(0);
  281. !         }
  282. !     } else
  283.           edge_vines(WidthOfScreen(screen) / 2, 10, FLIP);
  284. !     edge_vines(WidthOfScreen(screen) / 2, 10, FLOP);
  285.       exit(0);
  286.       }
  287.   #ifdef SIGCHLD
  288. --- 263,276 ----
  289.                   win_rects[my_win].r_top, FLOP);
  290.       exit(0);
  291.       }
  292. + #endif /* X11 */
  293.       y = 1;
  294.       if (do_edges) {
  295. !     if (!fork()) {
  296. !         init_display();
  297.           edge_vines(WidthOfScreen(screen) / 2, 10, FLIP);
  298. !     } else
  299. !         edge_vines(WidthOfScreen(screen) / 2, 10, FLOP);
  300.       exit(0);
  301.       }
  302.   #ifdef SIGCHLD
  303. ***************
  304. *** 312,320 ****
  305.           random_vines(WidthOfScreen(screen)/2, HeightOfScreen(screen)/2);
  306.       else
  307.           random_vines(x, y);
  308. - #ifdef X11
  309. -     XFlush(dpy);
  310. - #endif /* X11 */
  311.   }
  312.   
  313.   #ifdef SIGCHLD
  314. --- 282,287 ----
  315. ***************
  316. *** 357,362 ****
  317. --- 324,330 ----
  318.       draw_stem(&x, &y,
  319.           (random() % 2) * UP | ((which_way == FLIP) ? FLOP : FLIP));
  320.       */
  321. +     XFlush(dpy);
  322.   }
  323.   
  324.   random_vines(xstart, ystart)
  325. ***************
  326. *** 366,371 ****
  327. --- 334,340 ----
  328.       total_forks++;
  329.       return;
  330.       }
  331. +     init_display();
  332.       /* make the child think there are too many forks */
  333.       total_forks = MAX_FORKS;
  334.       srandom((int) (getpid() * time((long *) 0)));
  335. ***************
  336. *** 375,380 ****
  337. --- 344,350 ----
  338.       if (!(random() % (1 + (40 - branch_freq))))
  339.           random_vines(xstart, ystart);
  340.       }
  341. +     XFlush(dpy);
  342.       exit(0);
  343.   }
  344.   
  345. ***************
  346. *** 422,428 ****
  347.   
  348.   do_leaf(x,y)
  349.   {
  350. !     int reverse_it;
  351.       if (interleaf && (reverse_it = !(random() % interleaf)))
  352.       reverse = !reverse;
  353.       /* start at x,y and rotate */
  354. --- 392,398 ----
  355.   
  356.   do_leaf(x,y)
  357.   {
  358. !     int reverse_it = 0;
  359.       if (interleaf && (reverse_it = !(random() % interleaf)))
  360.       reverse = !reverse;
  361.       /* start at x,y and rotate */
  362. ***************
  363. *** 439,446 ****
  364.   long mirror;
  365.   {
  366.       static col;
  367. !     int tmp, ox = x, oy = y, nx, ny, npts[1];
  368. !     struct pr_pos leaf2[sizeof(leaf) / sizeof(struct pr_pos)];
  369.   
  370.       /* magnify, move leaf into position, and mirror, if necessary */
  371.       for(tmp = 0; tmp < leafsize; tmp++) {
  372. --- 409,419 ----
  373.   long mirror;
  374.   {
  375.       static col;
  376. !     int tmp, ox = x, oy = y, nx, ny;
  377. ! #ifndef X11
  378. !     int npts[1];
  379. ! #endif
  380. !     point_t leaf2[sizeof(leaf) / sizeof(point_t)];
  381.   
  382.       /* magnify, move leaf into position, and mirror, if necessary */
  383.       for(tmp = 0; tmp < leafsize; tmp++) {
  384. ***************
  385. *** 463,469 ****
  386.       reverse = !reverse;
  387.   #ifdef X11
  388.       XFillPolygon(dpy, win, gc, leaf2, 28, Nonconvex, CoordModeOrigin);
  389. -     XFlush(dpy);
  390.   #else /* X11 */
  391.       npts[0] = 28;   /* kludge for middle line of leaf! */
  392.       pr_polygon_2(screen, 0, 0, 1, npts, leaf2, RAS_OP, (Pixrect *) 0,0,0);
  393. --- 436,441 ----
  394. ***************
  395. *** 500,506 ****
  396.   
  397.   /* foreach pt in object, rotate_pt() */
  398.   rotate_obj(object, newobject, npts, rotation)
  399. ! struct pr_pos object[], newobject[];
  400.   double rotation;
  401.   {
  402.       int i;
  403. --- 472,478 ----
  404.   
  405.   /* foreach pt in object, rotate_pt() */
  406.   rotate_obj(object, newobject, npts, rotation)
  407. ! point_t object[], newobject[];
  408.   double rotation;
  409.   {
  410.       int i;
  411. ***************
  412. *** 510,516 ****
  413.   
  414.   /* matrix multiplication */
  415.   rotate_pt(oldpt,newpt,rot)
  416. ! struct pr_pos *oldpt, *newpt;
  417.   double rot;
  418.   {
  419.       /* temp storage -- might want to copy to itself */
  420. --- 482,488 ----
  421.   
  422.   /* matrix multiplication */
  423.   rotate_pt(oldpt,newpt,rot)
  424. ! point_t *oldpt, *newpt;
  425.   double rot;
  426.   {
  427.       /* temp storage -- might want to copy to itself */
  428. ***************
  429. *** 592,605 ****
  430.           leaf_file = optarg;
  431.           when 'S':
  432.           stem_file = optarg;
  433. -         when 'F':
  434. -         do_fork = 1;
  435.           when '?':
  436.           errors = 1;
  437.       }
  438.   
  439.       if (errors) {
  440. !     fprintf(stderr, err_msg[0], argv[0]);
  441.           for (c = 1; err_msg[c]; c++)
  442.           fprintf(stderr, "%s\n", err_msg[c]);
  443.       exit(1);
  444. --- 564,575 ----
  445.           leaf_file = optarg;
  446.           when 'S':
  447.           stem_file = optarg;
  448.           when '?':
  449.           errors = 1;
  450.       }
  451.   
  452.       if (errors) {
  453. !     fprintf(stderr, err_msg[0], prog_name);
  454.           for (c = 1; err_msg[c]; c++)
  455.           fprintf(stderr, "%s\n", err_msg[c]);
  456.       exit(1);
  457. ***************
  458. *** 608,619 ****
  459.   
  460.   #ifdef X11
  461.   get_windows(){}
  462.   initialize_color()
  463.   {
  464. -     u_char red[256], green[256], blue[256];
  465. -     XColor color;
  466.       Colormap cm = DefaultColormapOfScreen(screen);
  467.   
  468.       color.flags = DoRed | DoGreen | DoBlue;
  469.       for (max_color = 0; max_color < 256; max_color++) {
  470.       if (season) {
  471. --- 578,617 ----
  472.   
  473.   #ifdef X11
  474.   get_windows(){}
  475. + 
  476. + /*
  477. +  * Open the display (connection to the X server).  If it's already
  478. +  * open, close it and reopen it since this is a child process and
  479. +  * each child needs its own connection.
  480. +  */
  481. + init_display()
  482. + {
  483. +     int x_error(), first_time = !dpy;
  484. +     char *getenv(), *p = getenv("DISPLAY");
  485. + 
  486. +     if (dpy)
  487. +     XCloseDisplay(dpy);
  488. +     if (!(dpy = XOpenDisplay(device? device : p? p : ""))) {
  489. +     fprintf(stderr, "%s: unable to open display '%s'\n",
  490. +         prog_name, XDisplayName(p));
  491. +     exit(1);
  492. +     }
  493. +     XSetErrorHandler(x_error);
  494. +     screen = ScreenOfDisplay(dpy, DefaultScreen(dpy));
  495. +     win = RootWindowOfScreen(screen);
  496. +     gc = XCreateGC(dpy, win, 0L, NULL);
  497. +     if (first_time)
  498. +     initialize_color();
  499. +     XFlush(dpy);
  500. + }
  501. + 
  502. + XColor color;
  503.   initialize_color()
  504.   {
  505.       Colormap cm = DefaultColormapOfScreen(screen);
  506.   
  507. +     if (!is_color)
  508. +     return;
  509.       color.flags = DoRed | DoGreen | DoBlue;
  510.       for (max_color = 0; max_color < 256; max_color++) {
  511.       if (season) {
  512. ***************
  513. *** 624,638 ****
  514.           color.green = (255 - max_color/3)<<8;
  515.       }
  516.       color.blue = (max_color/5)<<8;
  517.       if (!XAllocColor(dpy, cm, &color)) {
  518.           printf("ran out of colors at index %d\n", max_color--);
  519.           break;
  520.       }
  521.       colors[max_color] = color.pixel;
  522.       }
  523.   }
  524.   
  525. ! void
  526.   x_error(display, error)
  527.   Display    *display;
  528.   XErrorEvent    *error;
  529. --- 622,640 ----
  530.           color.green = (255 - max_color/3)<<8;
  531.       }
  532.       color.blue = (max_color/5)<<8;
  533. +     if (dbug)
  534. +         printf("%d=", max_color);
  535.       if (!XAllocColor(dpy, cm, &color)) {
  536.           printf("ran out of colors at index %d\n", max_color--);
  537.           break;
  538.       }
  539.       colors[max_color] = color.pixel;
  540. +     if (dbug)
  541. +         printf("%d, ", color.pixel);
  542.       }
  543.   }
  544.   
  545. ! int
  546.   x_error(display, error)
  547.   Display    *display;
  548.   XErrorEvent    *error;
  549. ***************
  550. *** 651,661 ****
  551.       XGetErrorDatabaseText(display, "XRequest", num, num, buffer, BUFSIZ);
  552.       fprintf(stderr, " %s\n", buffer);
  553.   
  554.       /* abort to core dump or global debug flag set.. */
  555. !     abort(0);
  556.   }
  557.   
  558.   #else /* X11 */
  559.   get_windows()
  560.   {
  561.       char name[WIN_NAMESIZE];
  562. --- 653,685 ----
  563.       XGetErrorDatabaseText(display, "XRequest", num, num, buffer, BUFSIZ);
  564.       fprintf(stderr, " %s\n", buffer);
  565.   
  566. +     printf("color.red = %d, green = %d, blue = %d, pixel = %d\n",
  567. +     color.red>>8, color.green>>8, color.blue>>8, color.pixel);
  568.       /* abort to core dump or global debug flag set.. */
  569. !     /* abort(0); */
  570. !     exit(0);
  571.   }
  572.   
  573.   #else /* X11 */
  574. + 
  575. + init_display()
  576. + {
  577. +     char groups[PIXPG_OVERLAY+1];
  578. +     if (screen)
  579. +     return;
  580. +     if (!(screen = pr_open(device)))
  581. +     exit(1); /* pr_open prints its own error messages (bad idea) */
  582. + 
  583. +     pr_available_plane_groups(screen, sizeof(groups), groups);
  584. + 
  585. +     if (groups[PIXPG_OVERLAY] && groups[PIXPG_OVERLAY_ENABLE] && !is_color) {
  586. +     pr_set_plane_group(screen, PIXPG_OVERLAY_ENABLE);
  587. +     pr_rop(screen, 0,0, WidthOfScreen(screen), HeightOfScreen(screen),
  588. +         PIX_SET, (Pixrect *) 0,0,0);
  589. +     pr_set_plane_group(screen, PIXPG_OVERLAY);
  590. +     }
  591. + }
  592. + 
  593.   get_windows()
  594.   {
  595.       char name[WIN_NAMESIZE];
  596. dan
  597. -----------------------------------------------------------
  598.             O'Reilly && Associates
  599.         argv@sun.com / argv@ora.com
  600.        632 Petaluma Ave, Sebastopol, CA 95472 
  601.      800-338-NUTS, in CA: 800-533-NUTS, FAX 707-829-0104
  602.     Opinions expressed reflect those of the author only.
  603.